Computer systems and applications continually evolve to be ever more complex and capable. Even fairly inexpensive portable personal computer systems are routinely expected to support video application, for example. As a result, there is constant pressure on computer hardware and software developers to support increased capability and speed in systems that are affordable and relatively small. One of the responses to this pressure is central processing units (CPUs) with multiple processing cores that perform parallel processing. Parallel processing involves resource sharing among the multiple cores. Handling memory sharing is a significant challenge. For example, consider a situation in which one processing thread modifies the contents of a portion of memory for later use. Before the processing thread uses the modified contents, another processing thread might overwrites the portion of memory resulting in a loss of consistency between the memory locations. If the contents are not consistent a significant delay, or an error, results. Therefore, software mechanisms for multi-core processors and parallel processing have been developed.
One software mechanisms suitable for parallel processing is transactional memory (TM). TM is a concurrency control mechanism analogous to database transactions for controlling access to shared memory in multi-core computing. TM functions as an alternative to lock-based synchronization, and is typically implemented in a lock-free way. A transaction in this context is a piece of code that executes a series of reads and writes to shared memory. These reads and writes logically occur at a single instant in time, and intermediate states are not visible to other (successful) transactions. One can implement transactional memory either in software or hardware or a combination of the two. Software transactional memory (STM) may be semantically richer while hardware transactional memory (HTM) may have higher performance.
Many popular programming languages are object-oriented languages, such as Java. Object-oriented languages allow for application development in the context of heterogeneous, network-wide, distributed environments. Object-oriented languages may include automatic memory storage management to take over the burden of memory management from the programmer. One way this is accomplished is by using a garbage collector. Current TM systems and methods (referred to herein simply as TMs) may not be adapted to take advantage of all of the efficiencies that object-oriented applications are capable of. For example, current TMs may not efficiently maintain multiple version of objects, where some are speculative, some are definitive, and some are unreachable and therefore garbage. The indirection inherent in object-based garbage collection schemes may provide a mechanism for efficiently identifying and maintaining the various versions of objects, thus improving both memory management as well as the TM mechanisms.